﻿// ===============================================================================
// XCI.NET 西安交通信息WinForm开发框架 2018 版权所有
// ===============================================================================
using DevExpress.Data;
using DevExpress.XtraEditors;
using DevExpress.XtraTreeList.Columns;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows.Forms;
using XCI.Helper;

namespace XCI.Windows.Controls
{
    /// <summary>
    /// 扩展的树形控件
    /// </summary>
    [System.ComponentModel.DesignerCategory("Code")]
    [ToolboxItem(true)]
    public class TreeListx : DevExpress.XtraTreeList.TreeList
    {
        private string _id = StringHelper.Guid();
        private System.Windows.Forms.Timer autoFilterTimer;

        /// <summary>
        /// 表格Id
        /// </summary>
        [Browsable(false)]
        public virtual string Id
        {
            get => _id;
            set => _id = value;
        }

        protected override void OnEndInit()
        {

            base.OnEndInit();
            if (DesignMode) return;

            ViewInfo.PaintAppearance.HideSelectionRow.ForeColor = ViewInfo.PaintAppearance.FocusedRow.ForeColor;
            ViewInfo.PaintAppearance.HideSelectionRow.BackColor = ViewInfo.PaintAppearance.FocusedRow.BackColor;

            InitializeSearchEdit();
        }

        #region 过滤

        /// <summary>
        /// 搜索框
        /// </summary>
        [Browsable(true), DefaultValue(null), Category("XCI"), Description("搜索框")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public BaseEdit SearchEdit { get; set; }

        /// <summary>
        /// 搜索关键字改变事件
        /// </summary>
        public event EventHandler<EventArgs> FilterChanged;

        /// <summary>
        /// 搜索关键字改变事件
        /// </summary>
        protected void OnFilterChanged()
        {
            FilterChanged?.Invoke(this, EventArgs.Empty);
        }

        /// <summary>
        /// 初始化查询控件
        /// </summary>
        private void InitializeSearchEdit()
        {
            #region SearchEdit

            if (SearchEdit != null)
            {
                autoFilterTimer = new Timer();
                this.autoFilterTimer.Interval = OptionsFind.FindDelay;
                this.autoFilterTimer.Tick += this.autoFilterTimer_Tick;

                SearchEdit.KeyDown += SearchEdit_KeyDown;
                SearchEdit.EditValueChanged += SearchEdit_EditValueChanged;
            }

            #endregion
        }

        void autoFilterTimer_Tick(object sender, EventArgs e)
        {
            autoFilterTimer.Stop();
            if (!Visible || FindFilterText == SearchEdit.Text) return;
            Filter();
        }

        void SearchEdit_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Up)
            {
                e.Handled = true;
                MovePrev();
            }
            else if (e.KeyCode == Keys.Down)
            {
                e.Handled = true;
                MoveNext();
            }
            else if (e.KeyData == Keys.Enter)
            {
                e.Handled = true;
                Filter();
            }
            else if (e.KeyData == Keys.Escape)
            {
                if (SearchEdit.Text == string.Empty)
                {
                    return;
                }
                SearchEdit.Text = string.Empty;
            }
        }

        void SearchEdit_EditValueChanged(object sender, EventArgs e)
        {
            StartUpdateTimer();
        }

        void StartUpdateTimer()
        {
            autoFilterTimer.Stop();
            autoFilterTimer.Interval = OptionsFind.FindDelay;
            autoFilterTimer.Start();
        }

        /// <summary>
        /// 过滤
        /// </summary>
        public void Filter()
        {
            if (FindFilterText == SearchEdit.Text) return;
            Filter(SearchEdit.Text.Trim());
        }

        /// <summary>
        /// 过滤
        /// </summary>
        /// <param name="key">查询关键字</param>
        public void Filter(string key)
        {
            this.ApplyFindFilter(key.Trim());
            OnFilterChanged();
        }

        /// <summary>
        /// 延迟过滤
        /// </summary>
        public void DelayFilter()
        {
            StartUpdateTimer();
        }

        protected override List<IDataColumnInfo> GetFindToColumnsCollection()
        {
            List<IDataColumnInfo> list = new List<IDataColumnInfo>();
            foreach (TreeListColumn column in this.Columns)
            {
                list.Add(column);
            }
            return list;
        }

        #endregion


        //        private IList _dataList;
        //        private readonly Dictionary<string, PrimaryKeyValue> _dataChangedList = new Dictionary<string, PrimaryKeyValue>();
        //        private readonly Dictionary<string, string> checkedList = new Dictionary<string, string>();
        //        private FilterMode _filterMode = FilterMode.Extended;
        //        private bool _showPopupMenu = true;
        //        private bool _allowSettingGrid = true;
        //        private TreeListNode dragNode;
        //        private EntityData _metadata;
        //        private PopupMenu _popupMenus;
        //        private bool _isGenerated;
        //        private bool _autoGeneratedSetting = true;
        //        private System.Windows.Forms.Timer autoFilterTimer;

        //        #region 属性
        //        /// <summary>
        //        /// <para>
        //        /// Gets or sets the Tree's data source.
        //        /// </para>
        //        /// </summary>
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public new object DataSource
        //        {
        //            get
        //            {
        //                return base.DataSource;
        //            }
        //            set
        //            {
        //                var list = value as IList;
        //                if (list != null)
        //                {
        //                    if (_dataList == null)
        //                    {
        //                        _dataList = list;
        //                        base.DataSource = _dataList;
        //                    }
        //                    else
        //                    {
        //                        _dataList.Clear();
        //                        foreach (var item in list)
        //                        {
        //                            _dataList.Add(item);
        //                        }
        //                        RefreshDataSource();
        //                    }
        //                }
        //                else
        //                {
        //                    base.DataSource = value;
        //                }
        //                if (AutoGeneratedSetting && Metadata != null && !IsLoadGridSetting && !_isGenerated)
        //                {
        //                    AutoGeneratedColumn();
        //                }
        //            }
        //        }

        //        /// <summary>
        //        /// 是否已加载配置
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public bool IsLoadGridSetting { get; private set; }

        //        /// <summary>
        //        /// 实体图片序号字典(键:实体主键 值:图片序号)
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public Dictionary<string, int> EntityImageIndexDic { get; set; }

        //        /// <summary>
        //        /// 是否修改数据
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public bool HasDataChanged
        //        {
        //            get { return _dataChangedList.Count > 0; }
        //        }

        //        /// <summary>
        //        /// 是否显示右键菜单
        //        /// </summary>
        //        [Browsable(true), DefaultValue(true), Category("XCI"), Description("是否显示右键菜单")]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        [XtraSerializableProperty(XtraSerializationVisibility.Content, XtraSerializationFlags.DefaultValue)]
        //        public bool ShowPopupMenu
        //        {
        //            get { return _showPopupMenu; }
        //            set { _showPopupMenu = value; }
        //        }

        //        /// <summary>
        //        /// 是否允许设置表格属性
        //        /// </summary>
        //        [Browsable(true), DefaultValue(true), Category("XCI"), Description("是否允许设置表格属性")]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        public bool AllowSettingGrid
        //        {
        //            get { return _allowSettingGrid; }
        //            set { _allowSettingGrid = value; }
        //        }

        //        /// <summary>
        //        /// 没有自定义配置时自动生成
        //        /// </summary>
        //        [Browsable(true), DefaultValue(true), Category("XCI"), Description("没有自定义配置时自动生成")]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        public bool AutoGeneratedSetting
        //        {
        //            get { return _autoGeneratedSetting; }
        //            set { _autoGeneratedSetting = value; }
        //        }

        //        /// <summary>
        //        /// 是否自动展开第一个节点
        //        /// </summary>
        //        [Browsable(true), DefaultValue(false), Category("XCI"), Description("是否自动展开第一个节点")]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        public bool IsExpandFirstNode { get; set; }

        //        /// <summary>
        //        /// 是否展开所有节点
        //        /// </summary>
        //        [Browsable(true), DefaultValue(false), Category("XCI"), Description("是否展开所有节点")]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        public bool IsExpandAllNode { get; set; }

        //        /// <summary>
        //        /// 自动选中父节点
        //        /// </summary>
        //        [Browsable(true), DefaultValue(false), Category("XCI"), Description("自动选中父节点"),
        //        DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        public bool AutoCheckedParentNode { get; set; }

        //        /// <summary>
        //        /// 自动选中子节点
        //        /// </summary>
        //        [Browsable(true), DefaultValue(false), Category("XCI"), Description("自动选中子节点"),
        //        DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        public bool AutoCheckedChildNode { get; set; }

        //        /// <summary>
        //        /// 搜索框
        //        /// </summary>
        //        [Browsable(true), DefaultValue(null), Category("XCI"), Description("搜索框")]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        //        public ButtonEdit SearchEdit { get; set; }

        //        /// <summary>
        //        /// 右键菜单控件
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public PopupMenu PopupMenus
        //        {
        //            get
        //            {
        //                if (_popupMenus != null) return _popupMenus;
        //                if (this.MenuManager != null)
        //                {
        //                    _popupMenus = new PopupMenu();
        //                    _popupMenus.Manager = (BarManager)this.MenuManager;
        //                }
        //                return _popupMenus;
        //            }
        //            set { _popupMenus = value; }
        //        }

        //        /// <summary>
        //        /// 是否是当前层级结构中的第一个节点
        //        /// </summary>
        //        [Browsable(false)]
        //        public bool IsLevelFirstNode
        //        {
        //            get
        //            {
        //                if (FocusedNode != null)
        //                {
        //                    return GetNodeIndex(FocusedNode) == 0;
        //                }
        //                return false;
        //            }
        //        }

        //        /// <summary>
        //        /// 是否是当前层级结构中的最后一个节点
        //        /// </summary>
        //        [Browsable(false)]
        //        public bool IsLevelLastNode
        //        {
        //            get
        //            {
        //                if (FocusedNode != null)
        //                {
        //                    var node = FocusedNode;
        //                    int index = GetNodeIndex(node);
        //                    int count = GetParentNodeChildNodeCount(node);
        //                    if (index == count - 1)
        //                    {
        //                        return true;
        //                    }
        //                }
        //                return false;
        //            }
        //        }

        //        /// <summary>
        //        /// 是否行焦点在第一行
        //        /// </summary>
        //        [Browsable(false)]
        //        public bool IsFirstRow
        //        {
        //            get { return HasData && this.FocusedRowIndex == 0; }
        //        }

        //        /// <summary>
        //        /// 是否行焦点在最后一行
        //        /// </summary>
        //        [Browsable(false)]
        //        public bool IsLastRow
        //        {
        //            get { return HasData && this.FocusedRowIndex == this.RowCount - 1; }
        //        }

        //        /// <summary>
        //        /// 是否包含数据
        //        /// </summary>
        //        [Browsable(false)]
        //        public bool HasData
        //        {
        //            get { return Nodes.Count > 0; }
        //        }

        //        /// <summary>
        //        /// 是否选中数据
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public bool HasSelected
        //        {
        //            get { return this.FocusedNode != null; }
        //        }

        //        /// <summary>
        //        /// 当前是勾选多条
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public bool HasMultiChecked
        //        {
        //            get { return checkedList.Count > 1; }
        //        }

        //        /// <summary>
        //        /// 是否勾选数据
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public bool HasChecked
        //        {
        //            get { return checkedList.Count > 0; }
        //        }

        //        /// <summary>
        //        /// 实体元数据
        //        /// </summary>
        //        [Browsable(false)]
        //        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //        public EntityData Metadata
        //        {
        //            get { return _metadata; }
        //            set
        //            {
        //                _metadata = value;
        //                if (_metadata != null)
        //                {
        //                    KeyFieldName = _metadata.PrimaryProperty.Name;
        //                    ParentFieldName = _metadata.ParentProperty.Name;
        //                }
        //            }
        //        }

        //        /// <summary>
        //        /// 过滤模式
        //        /// </summary>
        //        [XtraSerializableProperty]
        //        [DefaultValue(FilterMode.Default)]
        //        public virtual FilterMode FilterMode
        //        {
        //            get { return _filterMode; }
        //            set
        //            {
        //                _filterMode = value;
        //                this.OptionsFilter.FilterMode = value;
        //            }
        //        }

        //        #endregion

        //        #region 事件

        //        /// <summary>
        //        /// 搜索关键字改变事件
        //        /// </summary>
        //        public event EventHandler<EventArgs> FilterChanged;

        //        /// <summary>
        //        /// 搜索关键字改变事件
        //        /// </summary>
        //        protected void OnFilterChanged()
        //        {
        //            if (FilterChanged != null)
        //            {
        //                FilterChanged(this, EventArgs.Empty);
        //            }
        //        }

        //        /// <summary>
        //        /// 数据发送变化事件
        //        /// </summary>
        //        public event EventHandler<EventArgs> DataChanged;

        //        protected void OnDataChanged(EventArgs e)
        //        {
        //            if (DataChanged != null)
        //            {
        //                DataChanged(this, e);
        //            }
        //        }

        //        /// <summary>
        //        /// 节点加载事件
        //        /// </summary>
        //        public event EventHandler<EventArgs> TreeNodeLoaded;
        //        protected void OnTreeNodeLoaded(EventArgs e)
        //        {
        //            if (TreeNodeLoaded != null)
        //            {
        //                TreeNodeLoaded(this, e);
        //            }
        //        }

        //        /// <summary>
        //        /// 节点勾选事件
        //        /// </summary>
        //        public event EventHandler<EventArgs> NodeChecked;
        //        protected void OnNodeChecked(EventArgs e)
        //        {
        //            if (NodeChecked != null)
        //            {
        //                NodeChecked(this, e);
        //            }
        //        }

        //        #endregion

        //        #region OnEndInit

        //        protected override void OnEndInit()
        //        {
        //            //if (DesignMode)
        //            //{
        //            //    this.OptionsBehavior.Editable = true;
        //            //    this.OptionsBehavior.AllowIndeterminateCheckState = false;
        //            //    this.OptionsBehavior.EnableFiltering = true;
        //            //    this.OptionsBehavior.AutoPopulateColumns = false;
        //            //    this.OptionsSelection.EnableAppearanceFocusedCell = false;
        //            //    this.OptionsFilter.FilterMode = FilterMode.Extended;
        //            //    this.OptionsView.ShowCheckBoxes = true;
        //            //    this.OptionsView.FocusRectStyle = DevExpress.XtraTreeList.DrawFocusRectStyle.None;
        //            //    this.OptionsView.AutoWidth = false;
        //            //    this.ShowButtonMode = ShowButtonModeEnum.ShowOnlyInEditor;
        //            //    this.IndicatorWidth = 35;
        //            //    this.RowHeight = 30;
        //            //}

        //            base.OnEndInit();
        //            if (DesignMode) return;

        //            ViewInfo.PaintAppearance.HideSelectionRow.BackColor = ViewInfo.PaintAppearance.FocusedRow.BackColor;

        //            InitializeRowNumber();
        //            InitializePopupMenu();
        //            InitializeSearchEdit();

        //            this.MouseUp += Tree_MouseUp;
        //            this.NodeCellStyle += Tree_NodeCellStyle;
        //            this.CellValueChanged += Tree_CellValueChanged;

        //            this.AfterCheckNode += Tree_AfterCheckNode;
        //            this.BeforeDragNode += Tree_BeforeDragNode;
        //            this.AfterDragNode += Tree_AfterDragNode;

        //            InitPlugin();
        //        }

        //        #endregion

        //        #region Timer


        //        #endregion

        //        #region OnLoaded Dispose

        //        protected override void OnLoaded()
        //        {
        //            base.OnLoaded();

        //            if (Nodes.Count > 0)
        //            {
        //                if (IsExpandAllNode)
        //                {
        //                    this.ExpandAll();
        //                }
        //                else if (IsExpandFirstNode)
        //                {
        //                    Nodes[0].Expanded = true;
        //                }
        //                //this.SetFocusedNode(Nodes[0]);
        //            }
        //            OnTreeNodeLoaded(EventArgs.Empty);
        //        }

        //        void Tree_NodeCellStyle(object sender, GetCustomNodeCellStyleEventArgs e)
        //        {
        //            if (e.Node.Checked)
        //            {
        //                e.Appearance.BackColor = ViewInfo.PaintAppearance.FocusedRow.BackColor;
        //                e.Appearance.ForeColor = ViewInfo.PaintAppearance.FocusedRow.ForeColor;
        //            }
        //        }

        //        #endregion

        //        #region 右键菜单

        //        public void AddPopupMenu(Bar bar)
        //        {
        //            foreach (LinkPersistInfo item in bar.LinksPersistInfo)
        //            {
        //                if (!(item.Item is BarButtonItem)) continue;
        //                PopupMenus.ItemLinks.Add(item.Item);
        //            }
        //        }

        //        private void InitializePopupMenu()
        //        {
        //            if (this.MenuManager == null || !ShowPopupMenu)
        //            {
        //                return;
        //            }
        //            foreach (BarItem item in PopupMenus.Manager.Items)
        //            {
        //                if (!(item is BarButtonItem)) continue;
        //                PopupMenus.ItemLinks.Add(item);
        //            }
        //        }

        //        void Tree_MouseUp(object sender, MouseEventArgs e)
        //        {
        //            if (ShowPopupMenu)
        //            {
        //                RightClickMethod(e, () => PopupMenus.ShowPopup(Control.MousePosition));
        //            }
        //        }

        //        public void RightClickMethod(MouseEventArgs e, Action action)
        //        {
        //            TreeListHitInfo hi = CalcHitInfo(e.Location);
        //            if (e.Button != MouseButtons.Right) return;

        //            if (hi.HitInfoType == HitInfoType.Cell && hi.Node != null)
        //            {
        //                FocusedNode = hi.Node;
        //            }

        //            if (PopupMenus != null && action != null
        //                && e.Button == MouseButtons.Right
        //                && ((hi.HitInfoType == HitInfoType.Cell) || (hi.HitInfoType == HitInfoType.Empty)))
        //            {
        //                action();
        //            }
        //        }

        //        #endregion

        //        #region 过滤

        //        /// <summary>
        //        /// 初始化查询控件
        //        /// </summary>
        //        private void InitializeSearchEdit()
        //        {
        //            #region SearchEdit

        //            if (SearchEdit != null)
        //            {
        //                autoFilterTimer = new Timer();
        //                this.autoFilterTimer.Interval = 1500;
        //                this.autoFilterTimer.Tick += this.autoFilterTimer_Tick;

        //                SearchEdit.KeyDown += SearchEdit_KeyDown;
        //                SearchEdit.EditValueChanged += SearchEdit_EditValueChanged;
        //            }

        //            #endregion
        //        }

        //        void autoFilterTimer_Tick(object sender, EventArgs e)
        //        {
        //            autoFilterTimer.Stop();
        //            if (!Visible || FindFilterText == SearchEdit.Text) return;
        //            Filter();
        //        }

        //        void SearchEdit_KeyDown(object sender, KeyEventArgs e)
        //        {
        //            if (e.KeyCode == Keys.Up)
        //            {
        //                e.Handled = true;
        //                MovePrev();
        //            }
        //            else if (e.KeyCode == Keys.Down)
        //            {
        //                e.Handled = true;
        //                MoveNext();
        //            }
        //            else if (e.KeyData == Keys.Enter)
        //            {
        //                e.Handled = true;
        //                Filter();
        //            }
        //            else if (e.KeyData == Keys.Escape)
        //            {
        //                if (SearchEdit.Text == string.Empty)
        //                {
        //                    return;
        //                }
        //                SearchEdit.Text = string.Empty;
        //            }
        //        }

        //        void SearchEdit_EditValueChanged(object sender, EventArgs e)
        //        {
        //            StartUpdateTimer();
        //        }
        //        void StartUpdateTimer()
        //        {
        //            autoFilterTimer.Stop();
        //            autoFilterTimer.Interval = OptionsFind.FindDelay;
        //            autoFilterTimer.Start();
        //        }

        //        /// <summary>
        //        /// 过滤树
        //        /// </summary>
        //        private void Filter()
        //        {
        //            Filter(SearchEdit.Text.Trim());
        //        }

        //        /// <summary>
        //        /// 过滤树
        //        /// </summary>
        //        /// <param name="key">查询关键字</param>
        //        public void Filter(string key)
        //        {
        //            this.ApplyFindFilter(key.Trim());
        //            OnFilterChanged();
        //        }

        //        protected override string[] GetFindColumnsNames()
        //        {
        //            List<string> list = new List<string>();
        //            foreach (TreeListColumn column in this.Columns)
        //            {
        //                if (this.GetAllowFindColumn(column))
        //                    list.Add("DxFts_" + column.FieldName);
        //            }
        //            return list.ToArray();
        //        }

        //        #endregion

        //        #region 行号

        //        private void InitializeRowNumber()
        //        {
        //            if (this.OptionsView.ShowIndicator)
        //            {
        //                this.CustomDrawNodeIndicator += (s, e) =>
        //                {
        //                    if (e.IsNodeIndicator)
        //                    {
        //                        TreeList tree = (DevExpress.XtraTreeList.TreeList)s;
        //                        IndicatorObjectInfoArgs args = (IndicatorObjectInfoArgs)e.ObjectArgs;
        //                        var index = tree.GetVisibleIndexByNode(e.Node);
        //                        args.DisplayText = index < 0 ? string.Empty : (index + 1).ToString();
        //                        e.ImageIndex = -1;
        //                    }
        //                };
        //            }
        //        }

        //        #endregion

        //        #region DataChanged

        //        /// <summary>
        //        /// 添加改变的列值
        //        /// </summary>
        //        /// <param name="item">改变项</param>
        //        private void AddDataChanged(PrimaryKeyValue item)
        //        {
        //            if (string.IsNullOrEmpty(item.Id)) return;
        //            PrimaryKeyValue _value;
        //            var cacheKey = item.Id + item.Key;
        //            if (_dataChangedList.TryGetValue(cacheKey, out _value))
        //            {
        //                _value.Value = item.Value;
        //            }
        //            else
        //            {
        //                _dataChangedList.Add(cacheKey, item);
        //            }
        //        }
        //        public void ClearDataChanged()
        //        {
        //            _dataChangedList.Clear();
        //        }

        //        /// <summary>
        //        /// 获取改变的数据
        //        /// </summary>
        //        /// <returns></returns>
        //        public List<PrimaryKeyValue> GetChangedDataList()
        //        {
        //            this.PostEditor();
        //            return _dataChangedList.Select(item => item.Value).ToList();
        //        }


        //        private void Tree_CellValueChanged(object sender, CellValueChangedEventArgs e)
        //        {
        //            if (e.Node == null || Metadata == null || string.IsNullOrEmpty(Metadata.PrimaryProperty.Name)) return;
        //            string columnName = e.Column.FieldName;
        //            string pk = GetDataId(e.Node);
        //            if (pk.IsEmpty()) return;
        //            string columnValue = e.Value.ToStringOrEmpty();
        //            AddDataChanged(new PrimaryKeyValue(pk, columnName, columnValue));
        //            OnDataChanged(EventArgs.Empty);
        //        }

        //        #endregion

        //        #region 拖拽节点

        //        private void Tree_BeforeDragNode(object sender, BeforeDragNodeEventArgs e)
        //        {
        //            dragNode = (TreeListNode)e.Node.Clone();
        //        }

        //        private void Tree_AfterDragNode(object sender, NodeEventArgs e)
        //        {
        //            if (Metadata.PathProperty==null) return;
        //            string sortName = Metadata.PathProperty.Name;
        //            if (string.IsNullOrEmpty(sortName)) return;
        //            if (e.Node == null || dragNode == null) return;

        //            string oldParentId = "0";
        //            string newParentId = "0";
        //            if (dragNode.ParentNode != null)
        //            {
        //                oldParentId = GetDataId(dragNode.ParentNode);
        //            }
        //            if (e.Node.ParentNode != null)
        //            {
        //                newParentId = GetDataId(e.Node.ParentNode);
        //            }

        //            if (!oldParentId.Equals(newParentId))//检测拖拽的节点的父节点发送变化了
        //            {
        //                //更新老节点顺序
        //                TreeListNodes oldnodes = dragNode.ParentNode == null ? Nodes : dragNode.ParentNode.Nodes;
        //                ChangedSortIndex(oldnodes);

        //                //更新新节点顺序
        //                TreeListNodes newnodes = e.Node.ParentNode == null ? Nodes : e.Node.ParentNode.Nodes;
        //                ChangedSortIndex(newnodes);

        //                //更新父节点
        //                AddDataChanged(new PrimaryKeyValue(GetDataId(e.Node), this.ParentFieldName, newParentId));
        //            }
        //            else //在同级中改变顺序,父节点不变
        //            {
        //                TreeListNodes nodes = e.Node.ParentNode == null ? Nodes : e.Node.ParentNode.Nodes;
        //                ChangedSortIndex(nodes);
        //            }
        //            OnDataChanged(EventArgs.Empty);
        //        }

        //        private void ChangedSortIndex(TreeListNodes nodes)
        //        {
        //            if (Metadata.PathProperty == null) return;
        //            string sortName = Metadata.PathProperty.Name;
        //            foreach (TreeListNode item in nodes)
        //            {
        //                AddDataChanged(new PrimaryKeyValue(GetDataId(item), sortName, GetNodeSortPath(item)));
        //            }
        //        }


        //        #endregion

        //        #region 复选框

        //        /// <summary>
        //        /// 递归选中父节点
        //        /// </summary>
        //        /// <param name="node"></param>
        //        /// <param name="action"></param>
        //        private void CheckedParentNodes(TreeListNode node, Action<TreeListNode> action)
        //        {
        //            RecursionParentNode(node, p =>
        //            {
        //                bool b = false;
        //                for (int i = 0; i < p.Nodes.Count; i++)
        //                {
        //                    CheckState state = p.Nodes[i].CheckState;
        //                    if (!node.CheckState.Equals(state))
        //                    {
        //                        b = true;
        //                        break;
        //                    }
        //                }
        //                p.CheckState = b ? CheckState.Checked : node.CheckState;
        //                if (action != null)
        //                {
        //                    action(p);
        //                }
        //            });
        //        }

        //        /// <summary>
        //        /// 递归选中子节点
        //        /// </summary>
        //        /// <param name="node"></param>
        //        /// <param name="action"></param>
        //        private void CheckedChildNodes(TreeListNode node, Action<TreeListNode> action)
        //        {
        //            RecursionChildNode(node, p =>
        //            {
        //                p.CheckState = node.CheckState;
        //                if (action != null)
        //                {
        //                    action(p);
        //                }
        //            });
        //        }

        //        /// <summary>
        //        /// 递归父节点
        //        /// </summary>
        //        /// <param name="node"></param>
        //        /// <param name="action"></param>
        //        public void RecursionParentNode(TreeListNode node, Action<TreeListNode> action)
        //        {
        //            if (node.ParentNode == null) return;
        //            var parentNode = node.ParentNode;
        //            action(parentNode);
        //            RecursionParentNode(parentNode, action);
        //        }

        //        /// <summary>
        //        /// 递归子节点
        //        /// </summary>
        //        /// <param name="node"></param>
        //        /// <param name="action"></param>
        //        public void RecursionChildNode(TreeListNode node, Action<TreeListNode> action)
        //        {
        //            if (!node.HasChildren) return;
        //            for (int i = 0; i < node.Nodes.Count; i++)
        //            {
        //                var cnode = node.Nodes[i];
        //                action(cnode);
        //                RecursionChildNode(cnode, action);
        //            }
        //        }

        //        /// <summary>
        //        /// 递归整个树节点
        //        /// </summary>
        //        /// <param name="action"></param>
        //        public void RecursionTreeNode(Action<TreeListNode> action)
        //        {
        //            foreach (TreeListNode node in this.Nodes)
        //            {
        //                action(node);
        //                if (node.HasChildren)
        //                {
        //                    RecursionChildNode(node, action);
        //                }
        //            }
        //        }

        //        /// <summary>
        //        /// 测试节点的子节点是否有勾选的节点
        //        /// </summary>
        //        /// <param name="node">测试节点</param>
        //        private bool ChildHasCheck(TreeListNode node)
        //        {
        //            foreach (TreeListNode item in node.Nodes)
        //            {
        //                if (item.Checked)
        //                {
        //                    return true;
        //                }
        //            }
        //            return false;
        //        }

        //        void Tree_AfterCheckNode(object sender, DevExpress.XtraTreeList.NodeEventArgs e)
        //        {
        //            if (AutoCheckedParentNode)
        //            {
        //                CheckedParentNodes(e.Node, p =>
        //                {
        //                    p.Checked = ChildHasCheck(p);
        //                    SetInnerCheckedNode(p);
        //                });
        //            }
        //            if (AutoCheckedChildNode)
        //            {
        //                var nodeChecked = e.Node.Checked;
        //                CheckedChildNodes(e.Node, p =>
        //                {
        //                    p.Checked = nodeChecked;
        //                    SetInnerCheckedNode(p);
        //                });
        //            }
        //            this.SetFocusedNode(e.Node);
        //            SetInnerCheckedNode(e.Node);
        //            OnNodeChecked(EventArgs.Empty);
        //        }

        //        /// <summary>
        //        /// 删除勾选的节点
        //        /// </summary>
        //        public void DeleteCheckedNodes()
        //        {
        //            var nodes = GetCheckedNodes();
        //            foreach (var item in nodes)
        //            {
        //                this.DeleteNode(item);
        //            }
        //            this.UncheckAll();
        //            ClearInnerCheckedNode();
        //        }

        //        #endregion

        //        #region 公共方法

        //        /// <summary>
        //        /// 获取表格二进制配置
        //        /// </summary>
        //        public string GetSetting()
        //        {
        //            this.ApplyFindFilter(null);
        //            var ms = new MemoryStream();
        //            SaveLayoutToStream(ms, OptionsLayoutBase.FullLayout);
        //            ms.Seek(0, System.IO.SeekOrigin.Begin);
        //            return Encoding.UTF8.GetString(ms.ToArray());
        //        }

        //        /// <summary>
        //        /// 应用表格二进制配置
        //        /// </summary>
        //        public void SetSetting(string setting)
        //        {
        //            if (string.IsNullOrEmpty(setting)) return;
        //            var data = Encoding.UTF8.GetBytes(setting);
        //            MemoryStream ms = IOHelper.ToMemoryStream(data);
        //            if (ms == null) return;
        //            RestoreLayoutFromStream(ms, OptionsLayoutBase.FullLayout);
        //            ms.Seek(0, System.IO.SeekOrigin.Begin);
        //            this.IsLoadGridSetting = true;
        //        }

        //        /// <summary>
        //        /// 设置内部复选状态
        //        /// </summary>
        //        /// <param name="node">节点</param>
        //        public void SetInnerCheckedNode(TreeListNode node)
        //        {
        //            string id = GetDataId(node);
        //            if (node.Checked)
        //            {
        //                checkedList[id] = id;
        //            }
        //            else
        //            {
        //                checkedList.Remove(id);
        //            }
        //        }

        //        /// <summary>
        //        /// 清空内部复选状态
        //        /// </summary>
        //        public void ClearInnerCheckedNode()
        //        {
        //            checkedList.Clear();
        //        }

        //        /// <summary>
        //        /// 获取指定节点的父节点的子节点个数
        //        /// </summary>
        //        /// <param name="node">指定的节点</param>
        //        private int GetParentNodeChildNodeCount(TreeListNode node)
        //        {
        //            return node.ParentNode == null ? Nodes.Count : node.ParentNode.Nodes.Count;
        //        }

        //        /// <summary>
        //        /// 展开第一个节点
        //        /// </summary>
        //        public void ExpandFirstNode()
        //        {
        //            if (Nodes.Count > 0)
        //            {
        //                Nodes[0].Expanded = true;
        //            }
        //        }

        //        /// <summary>
        //        /// 展开第一个节点
        //        /// </summary>
        //        public void FocusFirstNode()
        //        {
        //            if (Nodes.Count > 0)
        //            {
        //                SetFocusedNode(Nodes[0]);
        //            }
        //        }

        //        /// <summary>
        //        /// 获取选中的主键
        //        /// </summary>
        //        public string GetSelectedId()
        //        {
        //            if (this.FocusedNode != null)
        //            {
        //                return GetDataId(FocusedNode);
        //            }
        //            return string.Empty;
        //        }

        //        /// <summary>
        //        /// 获取勾选的主键数组
        //        /// </summary>
        //        public string[] GetCheckedIds()
        //        {
        //            var selectedNodes = GetCheckedNodes();
        //            string[] ids = new string[selectedNodes.Count];
        //            for (int i = 0; i < selectedNodes.Count; i++)
        //            {
        //                ids[i] = GetDataId(selectedNodes[i]);
        //            }
        //            return ids;
        //        }

        //        /// <summary>
        //        /// 获取主键
        //        /// </summary>
        //        /// <param name="node">选中的节点</param>
        //        public string GetDataId(TreeListNode node)
        //        {
        //            if (node == null)
        //            {
        //                return string.Empty;
        //            }
        //            object idObj;
        //            var dataRecord = GetDataRecordByNode(node);
        //            var rowView = dataRecord as DataRowView;
        //            if (rowView != null)
        //            {
        //                var row = rowView.Row;
        //                idObj = row[KeyFieldName];
        //            }
        //            else
        //            {
        //                idObj = ObjectHelper.GetObjectValue(dataRecord, KeyFieldName);
        //            }
        //            return idObj.ToStringOrEmpty();
        //        }

        //        /// <summary>
        //        /// 获取选中的节点
        //        /// </summary>
        //        public List<TreeListNode> GetCheckedNodes()
        //        {
        //            var selectedList = new List<TreeListNode>(this.RowCount);
        //            this.RecursionTreeNode(p =>
        //            {
        //                if (p.Checked)
        //                {
        //                    selectedList.Add(p);
        //                }
        //            });
        //            return selectedList;
        //        }

        //        /// <summary>
        //        /// 获取节点的排序路径
        //        /// </summary>
        //        /// <param name="node">节点</param>
        //        public string GetNodeSortPath(TreeListNode node)
        //        {
        //            if (node == null)
        //            {
        //                return GetNodeSortPathUnit(0);
        //            }
        //            var sortPath = new StringBuilder();
        //            GetNodeSortPathCore(node, sortPath);
        //            return sortPath.ToString();
        //        }

        //        private void GetNodeSortPathCore(TreeListNode node, StringBuilder sortPath)
        //        {
        //            var index = GetNodeSortPathUnit(this.GetNodeIndex(node));
        //            if (sortPath.Length == 0)
        //            {
        //                sortPath.Append(index);
        //            }
        //            else
        //            {
        //                sortPath.Insert(0, index);
        //            }

        //            if (node.ParentNode != null)
        //            {
        //                GetNodeSortPathCore(node.ParentNode, sortPath);
        //            }
        //        }

        //        /// <summary>
        //        /// 获取单个节点排序路径
        //        /// </summary>
        //        /// <param name="sortIndex">序号</param>
        //        /// <returns></returns>
        //        public static string GetNodeSortPathUnit(int sortIndex)
        //        {
        //            return StringHelper.GetFixedLengthString(sortIndex.ToString(), 4, "0", true);
        //        }

        //        /// <summary>
        //        /// 获取节点的父节点路径
        //        /// </summary>
        //        /// <param name="node">节点</param>
        //        public string GetNodeParentPath(TreeListNode node)
        //        {
        //            if (node == null)
        //            {
        //                return "0";
        //            }
        //            if (node.ParentNode == null)
        //            {
        //                return GetDataId(node);
        //            }
        //            var parentPath = new StringBuilder();
        //            GetNodeParentPathCore(node.ParentNode, parentPath);
        //            return parentPath.ToString();
        //        }

        //        private void GetNodeParentPathCore(TreeListNode parentNode, StringBuilder parentPath)
        //        {
        //            string parentId = this.GetDataId(parentNode);
        //            if (parentPath.Length == 0)
        //            {
        //                parentPath.Append(parentId);
        //            }
        //            else
        //            {
        //                parentPath.Insert(0, string.Concat(parentId, ","));
        //            }

        //            if (parentNode.ParentNode != null)
        //            {
        //                GetNodeParentPathCore(parentNode.ParentNode, parentPath);
        //            }
        //        }

        //        /// <summary>
        //        /// 执行双击事件
        //        /// </summary>
        //        public void DblClickMethod(EventArgs e, Action editAction)
        //        {
        //            var ev = e as MouseEventArgs;
        //            if (ev != null)
        //            {
        //                HitInfoType info = CalcHitInfo(ev.Location).HitInfoType;
        //                if (ev.Clicks == 2 && ev.Button == MouseButtons.Left &&
        //                    (info == HitInfoType.ColumnEdge
        //                    || info == HitInfoType.Button
        //                    || info == HitInfoType.Column
        //                    || info == HitInfoType.ColumnButton
        //                    || info == HitInfoType.NodeCheckBox
        //                    || info == HitInfoType.Empty))
        //                {
        //                    return;
        //                }
        //            }

        //            if (editAction != null && this.FocusedNode != null)
        //            {
        //                this.FocusedNode.Expanded = true;
        //                editAction();
        //            }
        //        }

        //        /// <summary>
        //        /// 保存改变的列值
        //        /// </summary>
        //        public void SaveChangedData()
        //        {
        //            //if (BatchSaveDataManage.Current == null) return;
        //            //if (DataChangedList.Count == 0) return;
        //            //this.PostEditor();
        //            //try
        //            //{
        //            //    BatchSaveDataManage.Current.BatchSaveData(Metadata, DataChangedList);
        //            //    DataChangedList.Clear();
        //            //}
        //            //catch (Exception e)
        //            //{
        //            //    MessageBoxHelper.ShowError(e.Message);
        //            //}
        //        }

        //        /// <summary>
        //        /// 触发BeforeCheckNode 和 AfterCheckNode 事件
        //        /// </summary>
        //        /// <param name="node">操作节点</param>
        //        public void RaiseCheckNode(TreeListNode node)
        //        {
        //            this.RaiseAfterCheckNode(node);
        //        }

        //        /// <summary>
        //        /// 循环数据源
        //        /// </summary>
        //        /// <typeparam name="T">实体类型</typeparam>
        //        /// <param name="action">执行动作</param>
        //        public void ForEachDataSouce<T>(Action<T> action) where T : new()
        //        {
        //            if (action == null) return;
        //            var source = this.DataSource;
        //            if (source == null) return;
        //            var table = source as DataTable;
        //            if (table != null)
        //            {
        //                foreach (DataRow row in table.Rows)
        //                {
        //                    var instance = new T();
        //                    DataTableHelper.WriteToEntity(row, instance);
        //                    action(instance);
        //                }
        //            }
        //            else
        //            {
        //                var list = source as IList;
        //                if (list == null) return;
        //                foreach (T obj in list)
        //                {
        //                    action(obj);
        //                }
        //            }
        //        }

        //        /// <summary>
        //        /// 根据主键查找节点
        //        /// </summary>
        //        /// <param name="id">主键</param>
        //        public TreeListNode FindNodeByDataId(object id)
        //        {
        //            if (id.IsEmpty())
        //            {
        //                return null;
        //            }
        //            if (Metadata==null)
        //            {
        //                return null;
        //            }
        //            var pkType = Metadata.AllColumns[KeyFieldName].Property.Property.PropertyType;
        //            var node = FindNodeByKeyID(ObjectHelper.ConvertObjectValue(id, pkType));
        //            return node;
        //        }

        //        /// <summary>
        //        /// 根据主键设置节点焦点
        //        /// </summary>
        //        /// <param name="id">主键</param>
        //        public void FocusNodeByDataId(object id)
        //        {
        //            var node = FindNodeByDataId(id);
        //            if (node != null)
        //            {
        //                SetFocusedNode(node);
        //            }
        //        }

        //        /// <summary>
        //        /// 自动生成列
        //        /// </summary>
        //        public void AutoGeneratedColumn()
        //        {
        //            if (Metadata == null)
        //            {
        //                Debug.WriteLine("请指定Metadata属性");
        //                return;
        //            }
        //            //this.OptionsBehavior.Editable = true;
        //            //this.OptionsBehavior.AllowIndeterminateCheckState = false;
        //            //this.OptionsBehavior.EnableFiltering = true;
        //            //this.OptionsBehavior.AutoPopulateColumns = false;
        //            //this.OptionsSelection.EnableAppearanceFocusedCell = false;
        //            //this.OptionsFilter.FilterMode = FilterMode.Extended;
        //            //this.OptionsBehavior.EnableFiltering = true;
        //            //this.OptionsView.ShowCheckBoxes = true;
        //            //this.OptionsView.FocusRectStyle = DevExpress.XtraTreeList.DrawFocusRectStyle.None;
        //            //this.OptionsView.AutoWidth = false;
        //            //this.ShowButtonMode = ShowButtonModeEnum.ShowOnlyInEditor;
        //            //this.IndicatorWidth = 35;
        //            //this.RowHeight = 30;
        //            this.Columns.Clear();

        //            int index = 0;
        //            foreach (var item in Metadata.AllColumns)
        //            {
        //                var col = item.Value;

        //                TreeListColumn column = this.Columns.Add();
        //                column.VisibleIndex = index + 1;
        //                column.Name = string.Format("treecol_{0}", StringHelper.Guid());
        //                column.FieldName = col.Name;
        //                column.Caption = col.Caption ?? col.Name;

        //                column.OptionsColumn.AllowEdit = false;
        //                var dataType = col.Property.Property.PropertyType;
        //                if (dataType == typeof(DateTime) || dataType == typeof(DateTime?))
        //                {
        //                    column.Format.FormatType = DevExpress.Utils.FormatType.DateTime;
        //                    column.Format.FormatString = "yyyy-MM-dd HH:mm:ss";
        //                }
        //                else if (dataType == typeof(decimal) || dataType == typeof(decimal?))
        //                {
        //                    column.Format.FormatType = DevExpress.Utils.FormatType.Numeric;
        //                    column.Format.FormatString = "#.##";
        //                }

        //                if (col.Name.Equals(Metadata.PrimaryProperty.Name)
        //                    || col.Name.Equals(this.ParentFieldName))
        //                {
        //                    column.Visible = false;
        //                }
        //                column.Visible = true;
        //                index++;
        //            }
        //            this.BestFitColumns();
        //            _isGenerated = true;
        //        }

        //        #endregion

        //        private void InitPlugin()
        //        {
        //            //new TreeListSettingPlugin().OnInit(this);

        //            //var plugins = PluginManage.GetPlugins<ITreeListPlugin>();
        //            //if (plugins.Length == 0) return;
        //            //plugins.ForEach(p =>
        //            //{
        //            //    try
        //            //    {
        //            //        p.OnInit(this);
        //            //    }
        //            //    catch (Exception e)
        //            //    {
        //            //        DebugHelper.Debug("加载插件" + XCI.Helper.AssemblyHelper.GetTypeFullName(p.GetType()) + "时发生异常:" + e.Message);
        //            //    }
        //            //});
        //        }
    }

}